home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / linux / lm_interface.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  7.1 KB  |  278 lines
  1. /*
  2.  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
  3.  * Copyright (C) 2004-2006 Red Hat, Inc.  All rights reserved.
  4.  *
  5.  * This copyrighted material is made available to anyone wishing to use,
  6.  * modify, copy, or redistribute it subject to the terms and conditions
  7.  * of the GNU General Public License version 2.
  8.  */
  9.  
  10. #ifndef __LM_INTERFACE_DOT_H__
  11. #define __LM_INTERFACE_DOT_H__
  12.  
  13.  
  14. typedef void (*lm_callback_t) (void *ptr, unsigned int type, void *data);
  15.  
  16. /*
  17.  * lm_mount() flags
  18.  *
  19.  * LM_MFLAG_SPECTATOR
  20.  * GFS is asking to join the filesystem's lockspace, but it doesn't want to
  21.  * modify the filesystem.  The lock module shouldn't assign a journal to the FS
  22.  * mount.  It shouldn't send recovery callbacks to the FS mount.  If the node
  23.  * dies or withdraws, all locks can be wiped immediately.
  24.  *
  25.  * LM_MFLAG_CONV_NODROP
  26.  * Do not allow the dlm to internally resolve conversion deadlocks by demoting
  27.  * the lock to unlocked and then reacquiring it in the requested mode. Instead,
  28.  * it should cancel the request and return LM_OUT_CONV_DEADLK.
  29.  */
  30.  
  31. #define LM_MFLAG_SPECTATOR    0x00000001
  32. #define LM_MFLAG_CONV_NODROP    0x00000002
  33.  
  34. /*
  35.  * lm_lockstruct flags
  36.  *
  37.  * LM_LSFLAG_LOCAL
  38.  * The lock_nolock module returns LM_LSFLAG_LOCAL to GFS, indicating that GFS
  39.  * can make single-node optimizations.
  40.  */
  41.  
  42. #define LM_LSFLAG_LOCAL        0x00000001
  43.  
  44. /*
  45.  * lm_lockname types
  46.  */
  47.  
  48. #define LM_TYPE_RESERVED    0x00
  49. #define LM_TYPE_NONDISK        0x01
  50. #define LM_TYPE_INODE        0x02
  51. #define LM_TYPE_RGRP        0x03
  52. #define LM_TYPE_META        0x04
  53. #define LM_TYPE_IOPEN        0x05
  54. #define LM_TYPE_FLOCK        0x06
  55. #define LM_TYPE_PLOCK        0x07
  56. #define LM_TYPE_QUOTA        0x08
  57. #define LM_TYPE_JOURNAL        0x09
  58.  
  59. /*
  60.  * lm_lock() states
  61.  *
  62.  * SHARED is compatible with SHARED, not with DEFERRED or EX.
  63.  * DEFERRED is compatible with DEFERRED, not with SHARED or EX.
  64.  */
  65.  
  66. #define LM_ST_UNLOCKED        0
  67. #define LM_ST_EXCLUSIVE        1
  68. #define LM_ST_DEFERRED        2
  69. #define LM_ST_SHARED        3
  70.  
  71. /*
  72.  * lm_lock() flags
  73.  *
  74.  * LM_FLAG_TRY
  75.  * Don't wait to acquire the lock if it can't be granted immediately.
  76.  *
  77.  * LM_FLAG_TRY_1CB
  78.  * Send one blocking callback if TRY is set and the lock is not granted.
  79.  *
  80.  * LM_FLAG_NOEXP
  81.  * GFS sets this flag on lock requests it makes while doing journal recovery.
  82.  * These special requests should not be blocked due to the recovery like
  83.  * ordinary locks would be.
  84.  *
  85.  * LM_FLAG_ANY
  86.  * A SHARED request may also be granted in DEFERRED, or a DEFERRED request may
  87.  * also be granted in SHARED.  The preferred state is whichever is compatible
  88.  * with other granted locks, or the specified state if no other locks exist.
  89.  *
  90.  * LM_FLAG_PRIORITY
  91.  * Override fairness considerations.  Suppose a lock is held in a shared state
  92.  * and there is a pending request for the deferred state.  A shared lock
  93.  * request with the priority flag would be allowed to bypass the deferred
  94.  * request and directly join the other shared lock.  A shared lock request
  95.  * without the priority flag might be forced to wait until the deferred
  96.  * requested had acquired and released the lock.
  97.  */
  98.  
  99. #define LM_FLAG_TRY        0x00000001
  100. #define LM_FLAG_TRY_1CB        0x00000002
  101. #define LM_FLAG_NOEXP        0x00000004
  102. #define LM_FLAG_ANY        0x00000008
  103. #define LM_FLAG_PRIORITY    0x00000010
  104.  
  105. /*
  106.  * lm_lock() and lm_async_cb return flags
  107.  *
  108.  * LM_OUT_ST_MASK
  109.  * Masks the lower two bits of lock state in the returned value.
  110.  *
  111.  * LM_OUT_CACHEABLE
  112.  * The lock hasn't been released so GFS can continue to cache data for it.
  113.  *
  114.  * LM_OUT_CANCELED
  115.  * The lock request was canceled.
  116.  *
  117.  * LM_OUT_ASYNC
  118.  * The result of the request will be returned in an LM_CB_ASYNC callback.
  119.  *
  120.  * LM_OUT_CONV_DEADLK
  121.  * The lock request was canceled do to a conversion deadlock.
  122.  */
  123.  
  124. #define LM_OUT_ST_MASK        0x00000003
  125. #define LM_OUT_CANCELED        0x00000008
  126. #define LM_OUT_ASYNC        0x00000080
  127. #define LM_OUT_ERROR        0x00000100
  128.  
  129. /*
  130.  * lm_callback_t types
  131.  *
  132.  * LM_CB_NEED_E LM_CB_NEED_D LM_CB_NEED_S
  133.  * Blocking callback, a remote node is requesting the given lock in
  134.  * EXCLUSIVE, DEFERRED, or SHARED.
  135.  *
  136.  * LM_CB_NEED_RECOVERY
  137.  * The given journal needs to be recovered.
  138.  *
  139.  * LM_CB_ASYNC
  140.  * The given lock has been granted.
  141.  */
  142.  
  143. #define LM_CB_NEED_E        257
  144. #define LM_CB_NEED_D        258
  145. #define LM_CB_NEED_S        259
  146. #define LM_CB_NEED_RECOVERY    260
  147. #define LM_CB_ASYNC        262
  148.  
  149. /*
  150.  * lm_recovery_done() messages
  151.  */
  152.  
  153. #define LM_RD_GAVEUP        308
  154. #define LM_RD_SUCCESS        309
  155.  
  156.  
  157. struct lm_lockname {
  158.     u64 ln_number;
  159.     unsigned int ln_type;
  160. };
  161.  
  162. #define lm_name_equal(name1, name2) \
  163.     (((name1)->ln_number == (name2)->ln_number) && \
  164.      ((name1)->ln_type == (name2)->ln_type)) \
  165.  
  166. struct lm_async_cb {
  167.     struct lm_lockname lc_name;
  168.     int lc_ret;
  169. };
  170.  
  171. struct lm_lockstruct;
  172.  
  173. struct lm_lockops {
  174.     const char *lm_proto_name;
  175.  
  176.     /*
  177.      * Mount/Unmount
  178.      */
  179.  
  180.     int (*lm_mount) (char *table_name, char *host_data,
  181.              lm_callback_t cb, void *cb_data,
  182.              unsigned int min_lvb_size, int flags,
  183.              struct lm_lockstruct *lockstruct,
  184.              struct kobject *fskobj);
  185.  
  186.     void (*lm_others_may_mount) (void *lockspace);
  187.  
  188.     void (*lm_unmount) (void *lockspace);
  189.  
  190.     void (*lm_withdraw) (void *lockspace);
  191.  
  192.     /*
  193.      * Lock oriented operations
  194.      */
  195.  
  196.     int (*lm_get_lock) (void *lockspace, struct lm_lockname *name, void **lockp);
  197.  
  198.     void (*lm_put_lock) (void *lock);
  199.  
  200.     unsigned int (*lm_lock) (void *lock, unsigned int cur_state,
  201.                  unsigned int req_state, unsigned int flags);
  202.  
  203.     unsigned int (*lm_unlock) (void *lock, unsigned int cur_state);
  204.  
  205.     void (*lm_cancel) (void *lock);
  206.  
  207.     int (*lm_hold_lvb) (void *lock, char **lvbp);
  208.     void (*lm_unhold_lvb) (void *lock, char *lvb);
  209.  
  210.     /*
  211.      * Posix Lock oriented operations
  212.      */
  213.  
  214.     int (*lm_plock_get) (void *lockspace, struct lm_lockname *name,
  215.                  struct file *file, struct file_lock *fl);
  216.  
  217.     int (*lm_plock) (void *lockspace, struct lm_lockname *name,
  218.              struct file *file, int cmd, struct file_lock *fl);
  219.  
  220.     int (*lm_punlock) (void *lockspace, struct lm_lockname *name,
  221.                struct file *file, struct file_lock *fl);
  222.  
  223.     /*
  224.      * Client oriented operations
  225.      */
  226.  
  227.     void (*lm_recovery_done) (void *lockspace, unsigned int jid,
  228.                   unsigned int message);
  229.  
  230.     struct module *lm_owner;
  231. };
  232.  
  233. /*
  234.  * lm_mount() return values
  235.  *
  236.  * ls_jid - the journal ID this node should use
  237.  * ls_first - this node is the first to mount the file system
  238.  * ls_lvb_size - size in bytes of lock value blocks
  239.  * ls_lockspace - lock module's context for this file system
  240.  * ls_ops - lock module's functions
  241.  * ls_flags - lock module features
  242.  */
  243.  
  244. struct lm_lockstruct {
  245.     unsigned int ls_jid;
  246.     unsigned int ls_first;
  247.     unsigned int ls_lvb_size;
  248.     void *ls_lockspace;
  249.     const struct lm_lockops *ls_ops;
  250.     int ls_flags;
  251. };
  252.  
  253. /*
  254.  * Lock module bottom interface.  A lock module makes itself available to GFS
  255.  * with these functions.
  256.  */
  257.  
  258. int gfs2_register_lockproto(const struct lm_lockops *proto);
  259. void gfs2_unregister_lockproto(const struct lm_lockops *proto);
  260.  
  261. /*
  262.  * Lock module top interface.  GFS calls these functions when mounting or
  263.  * unmounting a file system.
  264.  */
  265.  
  266. int gfs2_mount_lockproto(char *proto_name, char *table_name, char *host_data,
  267.              lm_callback_t cb, void *cb_data,
  268.              unsigned int min_lvb_size, int flags,
  269.              struct lm_lockstruct *lockstruct,
  270.              struct kobject *fskobj);
  271.  
  272. void gfs2_unmount_lockproto(struct lm_lockstruct *lockstruct);
  273.  
  274. void gfs2_withdraw_lockproto(struct lm_lockstruct *lockstruct);
  275.  
  276. #endif /* __LM_INTERFACE_DOT_H__ */
  277.  
  278.